home *** CD-ROM | disk | FTP | other *** search
/ Ian & Stuart's Australian Mac: Not for Sale / Another.not.for.sale (Australia).iso / fade into you / getting there / Apps / MOO-1.7.6.src / src / functions.c < prev    next >
Text File  |  1994-11-02  |  9KB  |  340 lines
  1. /******************************************************************************
  2.   Copyright (c) 1992 Xerox Corporation.  All rights reserved.
  3.   Portions of this code were written by Stephen White, aka ghond.
  4.   Use and copying of this software and preparation of derivative works based
  5.   upon this software are permitted.  Any distribution of this software or
  6.   derivative works must comply with all applicable United States export
  7.   control laws.  This software is made available AS IS, and Xerox Corporation
  8.   makes no warranty about the software, its performance or its conformity to
  9.   any specification.  Any person obtaining a copy of this software is requested
  10.   to send their name and post office or electronic mail address to:
  11.     Pavel Curtis
  12.     Xerox PARC
  13.     3333 Coyote Hill Rd.
  14.     Palo Alto, CA 94304
  15.     Pavel@Xerox.Com
  16.  *****************************************************************************/
  17.  
  18. #include "my-stdarg.h"
  19.  
  20. #include "config.h"
  21. #include "functions.h"
  22. #include "log.h"
  23. #include "storage.h"
  24. #include "structures.h"
  25. #include "utils.h" 
  26.  
  27. /*****************************************************************************
  28.  * This is the table of procedures that register MOO built-in functions.  To
  29.  * add new built-in functions to the server, add to the list below the name of
  30.  * a C function that will register your new MOO built-ins; your C function will
  31.  * be called exactly once, during server initialization.  Also add a
  32.  * declaration of that C function to `bf_register.h' and add the necessary .c
  33.  * files to the `CSRCS' line in the Makefile.
  34.  ****************************************************************************/
  35.  
  36. typedef void (*registry)();
  37.  
  38. static registry    bi_function_registries[] = {
  39.     register_execute,
  40.     register_list,
  41.     register_log,
  42.     register_numbers,
  43.     register_objects,
  44.     register_property,
  45.     register_server,
  46.     register_tasks,
  47.     register_verbs
  48.     };
  49.  
  50. void
  51. register_bi_functions()
  52. {
  53.     int loop, num_registries =
  54.     sizeof(bi_function_registries) / sizeof(bi_function_registries[0]);
  55.  
  56.     for (loop = 0; loop < num_registries; loop++)
  57.     (void) (*(bi_function_registries[loop]))();
  58. }
  59.  
  60. /*** register ***/
  61.  
  62. static struct bft_entry bf_table[MAX_FUNC];
  63. static unsigned top_bf_table = 0;
  64.  
  65. static unsigned
  66. register_common(const char *name, int minargs, int maxargs, bf_type func,
  67.         bf_read_type read, bf_write_type write, va_list args)
  68. {
  69.     int     va_index;
  70.     int     num_arg_types = maxargs == -1 ? minargs : maxargs;
  71.  
  72.     if (top_bf_table == MAX_FUNC) {
  73.     errlog("too many functions.  %s cannot be registered.\n", name);
  74.     return 0;
  75.     }
  76.  
  77.     bf_table[top_bf_table].name = str_dup(name);
  78.     bf_table[top_bf_table].minargs = minargs;
  79.     bf_table[top_bf_table].maxargs = maxargs;
  80.     bf_table[top_bf_table].func = func;
  81.     bf_table[top_bf_table].read = read;
  82.     bf_table[top_bf_table].write = write;
  83.  
  84.     if (num_arg_types > 0)
  85.     bf_table[top_bf_table].prototype =
  86.         mymalloc(num_arg_types * sizeof(var_type), M_VL_LIST);
  87.     else
  88.     bf_table[top_bf_table].prototype = 0;
  89.     for (va_index = 0; va_index < num_arg_types; va_index++)
  90.         bf_table[top_bf_table].prototype[va_index] = va_arg(args, var_type);
  91.  
  92.     return top_bf_table++;
  93. }
  94.      
  95. unsigned
  96. register_function(const char *name, int minargs, int maxargs,
  97.           bf_type func, ...)
  98. {
  99.     va_list args;
  100.     unsigned ans;
  101.  
  102.     va_start(args, func);
  103.     ans = register_common(name, minargs, maxargs, func, 0, 0, args);
  104.     va_end(args);
  105.     return ans;
  106. }
  107.   
  108. unsigned
  109. register_function_with_read_write(const char *name, int minargs, int maxargs,
  110.                   bf_type func, bf_read_type read,
  111.                   bf_write_type write, ...)
  112. {
  113.     va_list args;
  114.     unsigned ans;
  115.  
  116.     va_start(args, write);
  117.     ans = register_common(name, minargs, maxargs, func, read, write, args);
  118.     va_end(args);
  119.     return ans;
  120. }
  121.  
  122. void 
  123. free_bf_table(void)
  124. {
  125.     /* what an idea !!! */
  126.  
  127.     unsigned i;
  128.  
  129.     for (i = 0; i < top_bf_table; i++) {
  130.     free_str(bf_table[i].name);
  131.     if (bf_table[i].prototype)
  132.         myfree((void *) bf_table[i].prototype, M_VL_LIST);
  133.     }
  134. }
  135.  
  136. /*** looking up functions -- by name or num ***/
  137.  
  138. static const char *func_not_found_msg = "no such function";
  139.  
  140. const char *
  141. name_func_by_num(unsigned n) /* used by unparse only */
  142. {
  143.     if (n >= top_bf_table)
  144.     return func_not_found_msg;
  145.     else
  146.     return bf_table[n].name;
  147. }
  148.  
  149. unsigned
  150. number_func_by_name(const char *name) /* used by parser only */
  151. {
  152.     unsigned i;
  153.  
  154.     for (i = 0; i < top_bf_table; i++)
  155.     if (!mystrcasecmp(name, bf_table[i].name))
  156.         return i;
  157.  
  158.     return FUNC_NOT_FOUND;
  159. }
  160.  
  161. /*** calling built-in functions ***/
  162.  
  163. package 
  164. call_bi_func(unsigned n, Var arglist, Byte func_pc, 
  165.          Objid progr, void *vdata)
  166.      /* requires arglist.type == TYPE_LIST
  167.     call_bi_func will free arglist */
  168. {
  169.     struct bft_entry    f;
  170.  
  171.     if (n >= top_bf_table) {
  172.     errlog("CALL_BI_FUNC: Unknown function number: %d\n", n);
  173.     free_var(arglist);
  174.     return no_var_pack();
  175.     }
  176.  
  177.     f = bf_table[n];
  178.  
  179.     if (func_pc == 1) { /* check arg types and count *ONLY* for first entry */
  180.     int k, max;
  181.     Var *args = arglist.v.list;
  182.  
  183.     /*
  184.      * Check argument count
  185.      * (Can't always check in the compiler, because of @)
  186.      */
  187.     if (args[0].v.num < f.minargs
  188.         || (f.maxargs != -1 && args[0].v.num > f.maxargs)) {
  189.         free_var(arglist);
  190.         return make_error_pack(E_ARGS);
  191.     }
  192.  
  193.     /*
  194.      * Check argument types
  195.      */
  196.     max = (f.maxargs == -1) ? f.minargs : args[0].v.num;
  197.  
  198.     for (k = 0; k < max; k++)
  199.         if (f.prototype[k] != TYPE_ANY
  200.         && f.prototype[k] != args[k + 1].type) {
  201.         free_var(arglist);
  202.         return make_error_pack(E_TYPE);
  203.         }
  204.     }
  205.  
  206.     /*
  207.      * do the function
  208.      */
  209.  
  210.     return (*(f.func))(arglist, func_pc, vdata, progr);
  211.     /* f.func is responsible for freeing/using up arglist.
  212.        e.g., bf_pass on func_pc==2 will just use up (return) arglist.
  213.        well, tail recursion could be implemented in this special case */
  214.  
  215. }
  216.  
  217. void
  218. write_bi_func_data(void *vdata, Byte f_id)
  219. {
  220.     if (f_id >= top_bf_table) 
  221.     errlog("WRITE_BI_FUNC_DATA: Unknown function number: %d\n", f_id);
  222.     else if (bf_table[f_id].write)
  223.     (*(bf_table[f_id].write))(vdata);  
  224. }
  225.  
  226. int
  227. read_bi_func_data(FILE *f, Byte f_id, void **bi_func_state)
  228. {
  229.     if (f_id >= top_bf_table) {
  230.     errlog("READ_BI_FUNC_DATA: Unknown function number: %d\n", f_id);
  231.     *bi_func_state = 0;
  232.     return -1;
  233.     } else if (bf_table[f_id].read) {
  234.     *bi_func_state = (*(bf_table[f_id].read))(f);
  235.     if (*bi_func_state == 0) {
  236.         errlog("READ_BI_FUNC_DATA: Can't read data for %s()\n",
  237.            bf_table[f_id].name);
  238.         return -1;
  239.     }
  240.     } else
  241.     *bi_func_state = 0;
  242.     return 0;
  243. }
  244.  
  245.  
  246. package
  247. make_error_pack(enum error err)
  248. { 
  249.   package p;
  250.   p.why = BI_RAISE;
  251.   p.func_data = 0;
  252.   p.func_pc = 0;
  253.   p.u.err = err;
  254.   return p;
  255. }
  256.  
  257. package
  258. make_var_pack(Var v)
  259. {
  260.   package p;
  261.   p.why = BI_RETURN;
  262.   p.func_data = 0;
  263.   p.func_pc = 0;
  264.   p.u.ret = v;
  265.   return p;
  266. }
  267.  
  268. package
  269. no_var_pack(void)
  270. {
  271.   Var v;
  272.   v.type = TYPE_NUM;
  273.   v.v.num = 0;
  274.   return make_var_pack(v);
  275. }
  276.  
  277. package
  278. make_call_pack(Byte func_pc, void *func_data)
  279. {
  280.   package p;
  281.   p.why = BI_CALL;
  282.   p.func_data = func_data;
  283.   p.func_pc = func_pc;
  284.   return p;
  285. }
  286.  
  287. char rcsid_functions[] = "$Id: functions.c,v 1.14 1992/10/23 23:03:47 pavel Exp $";
  288.  
  289. /* $Log: functions.c,v $
  290.  * Revision 1.14  1992/10/23  23:03:47  pavel
  291.  * Added copyright notice.
  292.  *
  293.  * Revision 1.13  1992/10/23  19:25:30  pavel
  294.  * Eliminated all uses of the useless macro NULL..
  295.  *
  296.  * Revision 1.12  1992/10/21  03:02:35  pavel
  297.  * Converted to use new automatic configuration system.
  298.  *
  299.  * Revision 1.11  1992/10/17  20:31:03  pavel
  300.  * Changed return-type of read_bi_func_data() from char to int, for systems
  301.  * that use unsigned chars.
  302.  * Global rename of strdup->str_dup, strref->str_ref, vardup->var_dup, and
  303.  * varref->var_ref.
  304.  * Fixed bug in register_common() that sometimes read the wrong number of
  305.  * argument-types from the argument list.
  306.  *
  307.  * Revision 1.10  1992/09/08  22:02:46  pjames
  308.  * Updated register_* list to call functions by their new names.
  309.  *
  310.  * Revision 1.9  1992/08/28  16:01:31  pjames
  311.  * Changed myfree(*, M_STRING) to free_str(*).
  312.  *
  313.  * Revision 1.8  1992/08/14  01:20:25  pavel
  314.  * Made it entirely clear how to add new MOO built-in functions to the server.
  315.  *
  316.  * Revision 1.7  1992/08/14  00:40:31  pavel
  317.  * Added missing #include "my-stdarg.h"...
  318.  *
  319.  * Revision 1.6  1992/08/14  00:01:03  pavel
  320.  * Converted to a typedef of `var_type' = `enum var_type'.
  321.  *
  322.  * Revision 1.5  1992/08/13  21:27:11  pjames
  323.  * Added register_bi_functions() which calls all procedures which
  324.  * register built in functions.  To add another such procedure, just add
  325.  * it to the static list and to functions.h
  326.  *
  327.  * Revision 1.4  1992/08/12  01:48:42  pjames
  328.  * Builtin functions may now have as many arguments as desired.
  329.  *
  330.  * Revision 1.3  1992/08/10  17:39:46  pjames
  331.  * Changed registration method to use var_args.  Changed 'next' field to
  332.  * be func_pc.
  333.  *
  334.  * Revision 1.2  1992/07/21  00:02:29  pavel
  335.  * Added rcsid_<filename-root> declaration to hold the RCS ident. string.
  336.  *
  337.  * Revision 1.1  1992/07/20  23:23:12  pavel
  338.  * Initial RCS-controlled version.
  339.  */
  340.